package com.sx.dao.daoImpl;

import com.sx.dao.SupplierDao;
import com.sx.pojo.Category;
import com.sx.pojo.Supplier;
import com.sx.utils.DatabaseUtil;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

//供应商数据访问实现类
public class SupplierDaoImpl implements SupplierDao {
    //日志记录
    private final Logger logger = LogManager.getLogger(SupplierDaoImpl.class);

    /**
     * 获取所有供应商信息
     * 此方法连接数据库，查询supplier表中的所有记录，并将每条记录转换为Supplier对象，存储在ArrayList中返回
     * 它使用了DatabaseUtil类来获取数据库连接，并在查询结束后关闭所有使用的数据库资源
     *
     * @return 包含所有供应商信息的ArrayList对象，如果数据库操作失败或没有供应商信息，则返回空列表
     */
    @Override
    public ArrayList<Supplier> getAllSupplier() {
        //创建数据库连接
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        Supplier supplier;
        ArrayList<Supplier> supplierList = new ArrayList<>();
        try {
            //获取数据库连接
            connection = DatabaseUtil.getConnection();
            if (connection != null) {
                //准备SQL查询
                String sql = "select * from supplier";
                statement = connection.prepareStatement(sql);
                //执行查询并获取结果集
                resultSet = statement.executeQuery();
                //遍历结果集，将每条记录转换为Supplier对象，并添加到列表中
                while (resultSet.next()) {
                    supplier = new Supplier();
                    supplier.setId(resultSet.getString("id"));
                    supplier.setName(resultSet.getString("name"));
                    supplier.setAddress(resultSet.getString("address"));
                    supplier.setPhone(resultSet.getString("phone"));
                    supplier.setState(resultSet.getInt("state"));
                    supplierList.add(supplier);
                }
            }
        } catch (Exception e) {
            //记录数据库操作异常，并抛出运行时异常
            logger.error("数据库操作异常", e);
            throw new RuntimeException(e);
        } finally {
            // 关闭资源
            try {
                if (resultSet != null) resultSet.close();
                if (statement != null) statement.close();
                if (connection != null) connection.close();
            } catch (Exception e) {
                //记录关闭资源时的异常
                logger.error("关闭资源异常", e);
            }
        }
        //记录查询结果
        logger.info("查询到供应商数量：{}", supplierList.size());
        logger.info("查询到供应商信息：{}", supplierList);
        //返回包含所有供应商信息的列表
        return supplierList;
    }

    /**
     * 获取所有商品类别
     * 此方法连接数据库，查询所有商品类别的信息，并将这些信息封装到Category对象中，最后以ArrayList的形式返回
     *
     * @return 包含所有商品类别的ArrayList对象，如果数据库操作失败或没有找到任何类别，则返回空列表
     */
    @Override
    public ArrayList<Category> getAllCategory() {
        //创建数据库连接
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        Category category;
        ArrayList<Category> categoryList = new ArrayList<>();
        try {
            //获取数据库连接
            connection = DatabaseUtil.getConnection();
            if (connection != null) {
                //准备SQL查询
                String sql = "select * from category";
                statement = connection.prepareStatement(sql);
                //执行查询并获取结果集
                resultSet = statement.executeQuery();
                //遍历结果集，将每条记录转换为Category对象，并添加到列表中
                while (resultSet.next()) {
                    category = new Category();
                    category.setId(resultSet.getString("id"));
                    category.setName(resultSet.getString("name"));
                    categoryList.add(category);
                }
            }
        } catch (Exception e) {
            //记录数据库操作异常，并抛出运行时异常
            logger.error("数据库操作异常", e);
        } finally {
            // 关闭资源
            try {
                if (resultSet != null) resultSet.close();
                if (statement != null) statement.close();
                if (connection != null) connection.close();
            } catch (Exception e) {
                //记录关闭资源时的异常
                logger.error("关闭资源异常", e);
            }
        }
        //记录查询结果的日志信息
        logger.info("查询到商品类别数量：{}", categoryList.size());
        logger.info("查询到商品类别信息：{}", categoryList);
        //返回查询到的商品类别列表
        return categoryList;
    }

    @Override
    public boolean checkIdExists(String id) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = DatabaseUtil.getConnection();
            if (connection != null) {
                String sql = "SELECT COUNT(*) FROM supplier WHERE id = ?";
                preparedStatement = connection.prepareStatement(sql);
                preparedStatement.setString(1, id);
                resultSet = preparedStatement.executeQuery();
                if (resultSet.next()) {
                    logger.info("供应商ID存在：{}", id);
                    int count = resultSet.getInt(1);
                    return count > 0;
                }
            } else {
                logger.error("连接失败");
            }
        } catch (SQLException e) {
            logger.error("数据库操作异常", e);
        } finally {
            try {
                if (resultSet != null) resultSet.close();
                if (preparedStatement != null) preparedStatement.close();
                if (connection != null) connection.close();
            } catch (SQLException e) {
                logger.error("关闭资源异常", e);
            }
        }
        return false;
    }

    /**
     * 添加供应商到数据库
     * 此方法负责将供应商对象中的信息插入到数据库的supplier表中
     * 它涉及数据库连接、SQL语句的准备和执行，以及异常处理
     *
     * @param supplier 要添加的供应商对象，包含供应商的详细信息
     * @return 返回一个布尔值，表示供应商信息是否成功插入数据库
     */
    @Override
    public boolean addSupplier(Supplier supplier) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            // 获取数据库连接
            connection = DatabaseUtil.getConnection();
            if (connection != null) {
                // 准备SQL语句
                String sql = "INSERT INTO supplier (id, name, address, phone, state) VALUES (?, ?, ?, ?, ?)";
                preparedStatement = connection.prepareStatement(sql);
                // 设置SQL语句参数
                preparedStatement.setString(1, supplier.getId());
                preparedStatement.setString(2, supplier.getName());
                preparedStatement.setString(3, supplier.getAddress());
                preparedStatement.setString(4, supplier.getPhone());
                preparedStatement.setInt(5, supplier.getState());
                int i = preparedStatement.executeUpdate();
                // 执行插入操作，并根据执行结果返回布尔值
                logger.info("执行插入操作，并根据执行结果返回布尔值:{}", i);
                return i > 0;
            } else {
                // 记录数据库连接失败的错误
                logger.error("连接失败");
            }
        } catch (SQLException e) {
            // 记录数据库操作异常
            logger.error("数据库操作异常", e);
        } finally {
            // 关闭数据库资源
            try {
                if (preparedStatement != null) preparedStatement.close();
                if (connection != null) connection.close();
            } catch (SQLException e) {
                // 记录关闭资源异常
                logger.error("关闭资源异常", e);
            }
        }
        // 默认返回值，表示操作失败
        return false;
    }

    /**
     * 根据供应商ID删除供应商信息
     * 此方法尝试连接数据库并执行删除操作
     *
     * @param id 供应商的唯一标识符
     * @return 如果删除成功，则返回true；否则返回false
     */
    @Override
    public boolean deleteSupplierById(String id) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            // 获取数据库连接
            connection = DatabaseUtil.getConnection();
            if (connection != null) {
                // 准备SQL语句，执行删除操作
                String sql = "DELETE FROM supplier WHERE id = ?";
                preparedStatement = connection.prepareStatement(sql);
                preparedStatement.setString(1, id);
                int rowsAffected = preparedStatement.executeUpdate();
                // 记录删除操作的结果
                logger.info("执行删除操作，并根据执行结果返回布尔值:{}", rowsAffected);
                // 根据受影响的行数判断删除是否成功
                return rowsAffected > 0;
            } else {
                // 如果连接失败，记录错误信息
                logger.error("连接失败");
            }
        } catch (SQLException e) {
            // 处理SQL异常
            logger.error("数据库操作异常", e);
            throw new RuntimeException(e);
        } finally {
            // 关闭资源，释放连接
            try {
                if (preparedStatement != null) preparedStatement.close();
                if (connection != null) connection.close();
            } catch (SQLException e) {
                // 记录关闭资源时的异常信息
                logger.error("关闭资源异常", e);
            }
        }
        // 如果删除操作未成功，返回false
        return false;
    }

    /**
     * 根据供应商ID获取供应商信息
     * 此方法通过数据库查询来获取与给定ID匹配的供应商详细信息
     * 它首先尝试与数据库建立连接，然后执行查询操作，并在成功时返回供应商对象
     * 如果找不到供应商或连接失败，则返回null
     *
     * @param id 供应商的唯一标识符
     * @return 如果找到匹配的供应商，则返回Supplier对象；否则返回null
     */
    @Override
    public Supplier getSupplierById(String id) {
        // 定义数据库连接、预编译语句和结果集变量
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            // 尝试获取数据库连接
            connection = DatabaseUtil.getConnection();

            // 检查是否成功获取到连接
            if (connection != null) {
                // 定义查询语句并准备执行
                String sql = "select * from supplier where id=?";
                preparedStatement = connection.prepareStatement(sql);
                preparedStatement.setString(1, id);

                // 执行查询并处理结果
                resultSet = preparedStatement.executeQuery();
                if (resultSet.next()) {
                    // 创建供应商对象并设置其属性
                    Supplier supplier = new Supplier();
                    supplier.setId(resultSet.getString("id"));
                    supplier.setName(resultSet.getString("name"));
                    supplier.setAddress(resultSet.getString("address"));
                    supplier.setPhone(resultSet.getString("phone"));
                    supplier.setState(resultSet.getInt("state"));

                    // 记录查询到的供应商信息并返回供应商对象
                    logger.info("查询到供应商信息：{}", supplier);
                    return supplier;
                } else {
                    // 如果没有找到供应商，记录相关信息
                    logger.info("未找到供应商信息");
                }
            } else {
                // 如果连接失败，记录相关信息
                logger.info("连接失败");
            }
        } catch (SQLException e) {
            // 处理数据库操作中可能出现的异常
            logger.error("数据库操作异常", e);
        } finally {
            // 在操作完成后，确保关闭所有资源
            try {
                if (resultSet != null) resultSet.close();
                if (preparedStatement != null) preparedStatement.close();
            } catch (SQLException e) {
                // 处理关闭资源时可能出现的异常
                logger.error("关闭资源异常", e);
            }
        }

        // 如果没有找到供应商或出现异常，返回null
        return null;
    }

    /**
     * 更新供应商信息
     *
     * @param supplier 需要更新的供应商对象，包含供应商的各种信息
     * @return 返回更新操作是否成功，如果成功则返回true，否则返回false
     */
    @Override
    public boolean updateSupplier(Supplier supplier) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            // 获取数据库连接
            connection = DatabaseUtil.getConnection();
            if (connection != null) {
                // 准备SQL语句，用于更新供应商信息
                String sql = "UPDATE supplier SET name=?, address=?, phone=?, state=? WHERE id=?";
                preparedStatement = connection.prepareStatement(sql);
                // 设置SQL语句参数
                preparedStatement.setString(1, supplier.getName());
                preparedStatement.setString(2, supplier.getAddress());
                preparedStatement.setString(3, supplier.getPhone());
                preparedStatement.setInt(4, supplier.getState());
                preparedStatement.setString(5, supplier.getId());
                // 执行更新操作，并获取受影响的行数
                int rowsAffected = preparedStatement.executeUpdate();
                // 记录日志，显示更新操作的结果
                logger.info("执行更新操作，并根据执行结果返回布尔值:{}", rowsAffected);
                // 根据受影响的行数判断更新操作是否成功
                return rowsAffected > 0;
            } else {
                // 如果连接失败，记录错误日志
                logger.error("连接失败");
            }
        } catch (SQLException e) {
            // 如果数据库操作异常，记录错误日志
            logger.error("数据库操作异常", e);
        } finally {
            // 关闭资源，确保资源释放
            try {
                if (preparedStatement != null) preparedStatement.close();
                if (connection != null) connection.close();
            } catch (SQLException e) {
                // 如果关闭资源时发生异常，记录错误日志
                logger.error("关闭资源异常", e);
            }
        }
        // 如果更新操作失败，返回false
        return false;
    }
}
